-- card: 10251 from stack: in.3
-- bmap block id: 16119
-- flags: 4000
-- background id: 16896
-- name: MultiSort
----- HyperTalk script -----
on opencard
  global nextPos
  hide card field "source"
  set the scroll of card field "documentation" to 0
  hide button "arrow"
  put 0 into nextPos
  set the loc of btn arrow to "312,40"
  put empty into card field "sorted"
  pass opencard
end opencard

on Install
  get ChooseTargetStack()
  InstallResource XFCN,MultiSort,it
end Install


-- part 15 (field)
-- low flags: 01
-- high flags: 0004
-- rect: left=322 top=199 right=302 bottom=485
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 0
-- font id: 3
-- text size: 9
-- style flags: 0
-- line height: 12
-- part name: sorted


-- part 6 (button)
-- low flags: 00
-- high flags: 8003
-- rect: left=304 top=303 right=325 bottom=425
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 1
-- font id: 0
-- text size: 12
-- style flags: 0
-- line height: 16
-- part name: Show C Source
----- HyperTalk script -----
on mouseUp
  get the visible of card field "source"
  set the visible of card field "source" to not it
  if it is false then
    set the name of me to "Hide C Source"
  else
    set the name of me to "Show C Source"
  end if
end mouseUp



-- part 9 (field)
-- low flags: 01
-- high flags: 2007
-- rect: left=18 top=33 right=287 bottom=295
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 0
-- font id: 3
-- text size: 9
-- style flags: 0
-- line height: 12
-- part name: Documentation


-- part 11 (button)
-- low flags: 80
-- high flags: 0000
-- rect: left=303 top=29 right=51 bottom=321
-- title width / last selected line: 0
-- icon id / first selected line: 16560 / 16560
-- text alignment: 1
-- font id: 0
-- text size: 12
-- style flags: 0
-- line height: 16
-- part name: arrow


-- part 13 (field)
-- low flags: 01
-- high flags: 0004
-- rect: left=322 top=39 right=142 bottom=485
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 0
-- font id: 3
-- text size: 9
-- style flags: 0
-- line height: 12
-- part name: data


-- part 14 (field)
-- low flags: 01
-- high flags: 0004
-- rect: left=322 top=151 right=191 bottom=487
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 0
-- font id: 3
-- text size: 9
-- style flags: 0
-- line height: 12
-- part name: spec


-- part 7 (field)
-- low flags: 81
-- high flags: 0007
-- rect: left=18 top=31 right=290 bottom=489
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 0
-- font id: 3
-- text size: 10
-- style flags: 0
-- line height: 13
-- part name: Source


-- part 12 (button)
-- low flags: 00
-- high flags: A003
-- rect: left=85 top=298 right=320 bottom=185
-- title width / last selected line: 0
-- icon id / first selected line: 0 / 0
-- text alignment: 1
-- font id: 0
-- text size: 12
-- style flags: 0
-- line height: 16
-- part name: Sort
----- HyperTalk script -----
on mouseUp
  put MultiSort(card field "data",card field "spec") into card field "sorted"
end mouseUp



-- part contents for card part 7
----- text -----
/* MultiSort1.0d4.c */
/* © Trustees of Dartmouth College */
/* written in LightSpeed C  © Think Technologies, Inc */
/* by Roger Brown 9/2/89  Courseware Development Group */

/* version 1.0d4 uses international string comparison */
/* version 1.0d3 first source release */
/* version 1.0d2: clean up the code, change type spec to whole words. */
/* version 1.0d1: numbers are handled in floating point */
/* Distribution version. Source is for THINK C version 4.0, but I still use
   the qksort routine from THINK LSC™ v. 3.0 because the v 4.0 _qsort
   doesn't seem to work. */

/*  This is a HyperCard XFCN that sorts the lines of a HyperCard container
   according to the value of specified items in the line. It will do
   a multilevel sort on several items and can sort ascending or descending
   by alphabetic, numeric, time, or date order.
    There is no limit to the number of lines except for available memory.
    It uses the Lightspeed C quicksort function and it is quite fast! Only 
    one pass is made over the data to find line starts.
    Case is ignored in this version.
         
     Syntax is:
   
              get MultiSort(container,specification)
   
             where    container is any hypercard container (field, variable), 
                          presumed to be multi-lined.
                       specification is a container with this format:
                          for each item to sort on, in priority order,
                          specify one line of three items: item number to sort on,
                          sort type (alpha,numeric,date,time), and ascending or 
                          decending (a,d)

             returns: a copy of the container sorted by line
                           or error messages.
            
             ex.      get MultiSort(card field 1,spec)
             
                where spec is:
                2,alpha,a         item 2, alpahbetic order, ascending
                3,numeric,d       then item 3, numeric, descending
                
      Note on data formats:
          Time items must be in format hh:mm:ss (ex. 10:15:02). Seconds and hours are
          optional.  MultiSort WILL NOT report improperly formatted times and
          WILL NOT correct for mis-specified time (ex. 9:99 the way that
          HyperCard can. If you are uncertain of time data, convert it to seconds
          in HyperTalk and sort it numerically.
       
         Date items must be in format mm/dd/yy (ex. 2/15/78). All three parts must
         be specified.  MultiSort WILL NOT report improperly formatted dates and
          WILL NOT correct for mis-specified dates (ex. 1/44/50) the way that
          HyperCard can. If you are uncertain of date data, convert it to seconds
          in HyperTalk and sort it numerically.
          
                 
      To compile: create a project with this, MacTraps, and the THINK LightSpeed C™
      version 3.0 library source called qsort.c.  (The THINK C™ version 4.0 code
      does not work with this XFCN in its present state.) and a file called 
      C Utilities.c that you can generate from the C Utilities card of Dartmouth XCMD's. 
      Build as code resource type XFCN named MultiSort, ID 2351.
*/

#include "MemoryMgr.h"
#include "HyperXCmd.h"
#include "sane.h"
#include "XCmdGlue.inc.c"
#include "SetUpA4.h"

#define NULL 0L
#define maxItems 32
#define alpha     1
#define numeric   2
#define time  3
#define date      4
#define ascend    1
#define descend   2

#define slash '/'
#define colon ':'

#define memoryError -1            /* marks a memory allocation error */
int *order;                       /* points to the line order array (in heap) */
Handle orderHandle;               /* handle to the line order array */ 
int *lineStarts;                  /* points to array of line starts (in heap) */
Handle lsHandle;                  /* handle to the line starts array */      
Handle theField;                  /* handle to the input copy of the container */
Handle theUCASEField;             /* handle to an upper case version of container */
Handle DoSort();                  /* the sorting routine */
int numSortFields;                /* number of fields to sort on */
long sortItem[maxItems];          /* the number of the sort items */
char sortType[maxItems];          /* how to sort */
char sortDirection[maxItems];     /* which direction to sort */
long MyDateToSecs();


/* ------------------- utility functions ---------------------- */

/* change a string to all upper case */

ucase(s)
char *s;
{
int i;
char c;

for (i=0;i<strlen(s);i++) {
s[i] = toupper(s[i]);
}
}

/* Get the number of HyperCard comma delimited items in string s. */

int NumHCItems(s)
char *s;
{
int c;                                           /* character pointer */
int len;                                         /* length of string */
int count;                                       /* count of items found */
int j;                                           /* item byte counter */  

count = j = 0;                            /* initialize */
len = strlen(s);                                 /* will look this far */
for (c=0;c<len;c++) {                            /* scan all characters */
if (s[c]==',') {                             /* found end of an item */
count = count + 1;                       /* bump item found counter */
j = 0;                                   /* reset item scan counter */
}
else {                                       
j++;                                     /* bump item byte counter */
if (c==(len-1)) {                        /* last item, no comma */
count = count+1;                     /* this one counts, too */
break;
}
}
}
return count;
}

/* Get HyperCard comma delimited item i from item list string inStr. Return it in outStr */
/* item must be smaller than 255 characters */

GetHCItem(inStr,i,outStr)
char *inStr,*outStr;
int i;
{
int c;                                           /* character pointer */
int len;                                         /* length to scan */
int count;                                       /* count of items found */
int j;                                           /* item byte count */
Str255 temp;                                     /* collect item here, hope its < 255 */

count = j = 0;                                   /* initialize */
len = strlen(inStr);                             /* go this far, max */
for (c=0;c<len;c++) {
if (inStr[c]==',') {                         /* at an item boundary */
count = count + 1;                       /* bump counter */
if (count==i) break;                     /* if this is it, stop scanning */
j = 0;                                   /* else start on the next item */
}
else {
temp[j] = inStr[c];                      /* collect characters to return */
j++;                                     /* go to next */
if (j==255) {                            /* sorry, too big to store */
strcpy(temp,"Error: Item > 255 characters.");
return;                       
}
if (c==(len-1)) {                        /* last item, no comma */
count = count+1;
break;
}
}
}
if (count < i) strcpy(outStr,"Error: item out of range");   /* no item there */
else {
temp[j] = 0;                                     /* make it a C string */
strcpy(outStr,temp);                             /* move to output string */
}
return;
}

/* how many HyperCard lines in string source  */

NumHCLines(source) 
char *source;
{
int c;                                           /* character counter */
int l;                                           /* line counter */
int len;

len = strlen(source);
l = 0;
for (c=0;c<len;c++) {                            /* scan to desired line */
if (source[c]==13) l++;
}
if (source[c-1]!=13) l++;                        /* last line might not have CR */
return l;

}
/* get HyperCard line from source and return in dest */

GetHCLine(line,source,dest)
int line;
char *source,*dest;
{
int i;                                                /* char counter before line */
int j;                                                /* char cou,tner after line */
int c;                                                /* line counter */
int len;                                              /* length of source */

len = strlen(source);                                 /* go this far, max */
c = 1;                                                /* initialize */
i = 0;
while (c<line) {                                      /* cycle to desired line */
if (source[i]==13) c++;                           /* bump line count */
i++;
if (i>len) {                                      /* out of range */
strcpy(dest,"Error: Line out of range."); 
return;
}
}
c = 0;                                                /* at line, start transfer */
for (j=i;j<len;j++) {
*(dest+c) = source[j];
if (source[j]==13) break;                         /* line ended */
c++;
}
*(dest+c) = (char)0;                                  /* make into a C string */
}

/* build a return result structure from a string */

ResultIs(paramPtr,theResult)
XCmdBlockPtrparamPtr;
char *theResult;
{
long len;
Handle resultHandle;
len = 1+strlen(theResult);
resultHandle = NewHandle(len);
BlockMove(theResult,*resultHandle,len);
paramPtr->returnValue = resultHandle;
}

/* check string for valid ascii and convert if ok. Return validity.
   Input string is changed to Pascal format */

char ValidStrToNum(s,n)
char *s;
long *n; 
{
int c,len;

/* length must be < 32768 */
len = strlen(s);
if ((len<1)||(len>32768)) return FALSE; /* all characters must be 0..9,-,+ */
for (c=0;c<len;c++) {
   if ((s[c]<48)||(s[c]>57))
      if ((s[c]!=45)&&(s[c]!=43)) return FALSE;
}
CtoPstr(s);
StringToNum(s,n);
return TRUE;
}

/* Get part of string "to" from characters "start" to "stop".  Return it in 
   string "from" */
      
SubString(to,from,start,stop)
char *to,*from;
int start,stop;
{
int i,j;
j = 0;
for (i=start;i<stop;i++,j++) {
to[j] = from[i];
}
to[j] = 0;
}

/* Determine the integer value of a number expressed in a C string. */

CStrToInt(str)
char *str;
{
long n;

CtoPstr((char*)str);
StringToNum(str,&n);
return (int)n;
}

/* Determine the extended value of a number expressed in a C string. */

extended CStrToExtended(s)
char *s;
{
CtoPstr((char*)s);
return str2num(s);
}

/* -------------------- program code ---------------------- */

/* Get all line starts in one sweep, changing CRs to 0 bytes so that
    I have real C strings to work with later. Also process an upper case 
    copy of the input data by changing CRs to 0s and upper casing 
    everthing else. We process both copies because we want to sort the
    upper case version but reassemble the result from the original. 
   
    Returns the number of lines found.
*/
   
GetLineStarts(source,ucSource)
char *source,*ucSource;    /* the data source and a copy to ucase */
{
        int c;/* character counter */
        int l;/* line counter */
        long startsSize;/* size of the line starts array */
        
        /* allocate some memry to hold the line starts "array" */
        startsSize = 128;              /* arbitrary starting size */
        lsHandle = NewHandle(startsSize*2);
        if (lsHandle==NULL) {          /* handle error */
                SysBeep(60);
                return memoryError;
        }
        HLock(lsHandle);                  
        lineStarts = (int *)*lsHandle;
        
        /* scan the input data to find line starts */
        l = c = 0;
        *lineStarts = 0;                     /* first line starts at byte 0 */
        while (source[c] != 0) {               /* scan to end */
                if (source[c]==13) {            /* at end of a line */
                        l++;
                        *(lineStarts+l) = c+1;      /* next one starts here */
                        source[c] = 0;               /* change cr to 0 */
                        ucSource[c] = 0;           /* and do same to the ucase version */
                        if (l==startsSize-10) {     /* need more room for line starts */
                                startsSize = startsSize + 128;
                                HUnlock(lsHandle);
                                SetHandleSize(lsHandle,startsSize*2);
                                if (lsHandle==NULL) {    /* oops, out of room */
                                        SysBeep(60);
                                        return memoryError;
                                }
                                HLock(lsHandle);
                                lineStarts = (int *)*lsHandle;  /* it might have moved */
                        }
                }
                ucSource[c] = toupper(ucSource[c]);  /* change to ucase in line */
                c++;
        }
        if (source[c-1]==0) l--;           /* last line might not have CR */
        return l+1;                         
}


/* compare two numbers, return -1 if the first is larger, 1 if the second is larger
   and 0 if they are equal */
   
CompareNums(n1,n2)
char *n1,*n2;
{
char t1[64],t2[64];
extended num1,num2;

strcpy(t1,n1);
strcpy(t2,n2);
num1 = CStrToExtended(t1);
num2 = CStrToExtended(t2);
if (num1 < num2) return -1;
else if (num1 > num2) return 1;
return 0;
}

/* Change a date in character format into a DateTimeRec format. */

ParseDate(tStr,dtr)
char *tStr;
DateTimeRec *dtr;
{
/* Input must be in mm/dd/yy format */

int delim[3],next = 0;
char monthStr[16],dayStr[16],yearStr[16];
char *p;

delim[0] = delim[1] = delim[2] = 0;
p = tStr;
while (1) {                  /* find the '/' delimeters */
if ((*p==slash)||(*p=='\0')) {
delim[next] = (p-tStr);
next++;
}
if (*p == '\0') break;
p++;
}
SubString(monthStr,tStr,0,delim[0]);           /* get the 3 parts */
SubString(dayStr,tStr,delim[0]+1,delim[1]);
SubString(yearStr,tStr,delim[1]+1,delim[2]);
dtr->month = CStrToInt(monthStr);              /* convert */
dtr->day = CStrToInt(dayStr);
dtr->year = CStrToInt(yearStr);
}

/* Compare two dates in DateTimeRec format.  Return -1 if the first is later,
   0 if they are equal, and 1 if the second is later. */
   
CompareDates(d1,d2)
char *d1,*d2;
{
DateTimeRec dtr[2];

ParseDate(d1,&dtr[0]);
ParseDate(d2,&dtr[1]);

if (dtr[0].year > dtr[1].year) return 1;
else if (dtr[0].year < dtr[1].year) return -1;
if (dtr[0].month > dtr[1].month) return 1;
else if (dtr[0].month < dtr[1].month) return -1;
if (dtr[0].day > dtr[1].day) return 1;
else if (dtr[0].day < dtr[1].day) return -1;
return 0;
}

/* Change a time in character format into a DateTimeRec format. */

ParseTime(tStr,dtr)
char *tStr;
DateTimeRec *dtr;
{
/* Time must be in hh:mm:ss format. */

int delim[3],next = 0;
char hourStr[16],minStr[16],secStr[16];
char *p;

delim[0] = delim[1] = delim[2] = 0;    /* find the ":" delimeters */
p = tStr;
while (1) {
if ((*p==colon)||(*p=='\0')) {
delim[next] = (p-tStr);
next++;
}
if (*p == '\0') break;
p++;
}   
SubString(hourStr,tStr,0,delim[0]);         /* get the parts */
SubString(minStr,tStr,delim[0]+1,delim[1]);
SubString(secStr,tStr,delim[1]+1,delim[2]);
dtr->hour = CStrToInt(hourStr);              /* convert */
dtr->minute = CStrToInt(minStr);
dtr->second = CStrToInt(secStr);
}

/* Compare two tiems in DateTimeRec format.  Return -1 if the first is later,
   0 if they are equal, and 1 if the second is later. */

CompareTimes(t1,t2)
char *t1,*t2;
{
DateTimeRec dtr[2];

ParseTime(t1,&dtr[0]);
ParseTime(t2,&dtr[1]);

if (dtr[0].hour > dtr[1].hour) return 1;
else if (dtr[0].hour < dtr[1].hour) return -1;
if (dtr[0].minute > dtr[1].minute) return 1;
else if (dtr[0].minute < dtr[1].minute) return -1;
if (dtr[0].second > dtr[1].second) return 1;
else if (dtr[0].second < dtr[1].second) return -1;
return 0;
}

/* compare two fields (items). Comparison depends on field type and the
   result is adjusted for ascending or descending specification */
   
CompareFields(f1,f2,type,dir) 
char *f1,*f2;                      /* string value of the 2 fields */
char type,dir;                     /* field type and direction */
{
int result;
int len1,len2;

switch (type) {
case alpha:
len1 = strlen(f1);
len2 = strlen(f2);
result = IUMagString(f1,f2,len1,len2);
break;
case numeric:
result = CompareNums(f1,f2);
break;
case date:
result = CompareDates(f1,f2);
break;
case time:
result = CompareDates(f1,f2);
break;
}
if (dir == descend) 
result = -1*result;
return result;
}

/* Compare line i and line j. This function is an input to qsort. */

static int compare(i,j)
int i,j;
{
int f,result;
Str255 item1,item2;

for (f=0;f<numSortFields;f++) {        /* scan all sort fields */
GetHCItem(*theUCASEField+*(lineStarts+order[i]),(int)sortItem[f],item1);
  GetHCItem(*theUCASEField+*(lineStarts+order[j]),(int)sortItem[f],item2);
  result = CompareFields(item1,item2,sortType[f],sortDirection[f]);
  if (result!=0) {
  return result;  
  }  
  }
  return 0;           /* lines match */
}

/* Swap line i with line j. This function is an input to qsort. */

static void swap(i,j)
int i,j;
{
        int swap;
        swap = order[i];             /* We don't swap them in place, just */
        order[i] = order[j];         /* their positions in the order array */
        order[j] = swap;
}

/* Do the sort and return a handle to the sorted result */

Handle DoSort()
{
        Handle tempField;          /* handle to memory to build the result */
        int i,j,next;
        int numLines;
        Str255 temp1;
        OSErr err;
        long orderSize;
        long test;
        char c;
        int sLen,last;
        
        /* make a copy of the data to convert to upper case */
        
        theUCASEField = theField;
        err = HandToHand(&theUCASEField);   
        if (err != noErr) {                      /* some memory problem */
                tempField = NewHandle(32);       /* hope it fits */
                strcpy(*tempField,"Not enough memory to sort (1)");
                return tempField;
        }
        HLock(theUCASEField);                   /* lock these down so we use pointers to them */
        HLock(theField);
        
        /* get line starts, number of lines, and an uppercase copy */
        
        numLines = GetLineStarts(*theField,*theUCASEField);
        if (numLines == memoryError) {    /* some memory problem */
                tempField = NewHandle(32); 
                strcpy(*tempField,"Not enough memory to sort (2)");
                return tempField;
        }
        
        /* allocate space for the order array */
        
        orderSize = (numLines+1)*2;                /* this is an integer array */
        orderHandle = NewHandle(orderSize);
        if (orderHandle==NULL) {                   /* some memory problem */
                tempField = NewHandle(32); 
                strcpy(*tempField,"Not enough memory to sort (3)");
                return tempField;
        }
        
        /* lock it down so we can use a pointer to it */
        
        HLock(orderHandle);
        order = (int *)*orderHandle;
        
         /* initialize the order list */
         
        for (i=0;i<numLines;i++)
                order[i] = i;    
        
        /* let THINK C qksort do the hard work for us */
        
        qksort(numLines,compare,swap);
        
        /* Now build the sorted result: grab each line in the new order
             as a C string and concatenate it to the result string. */
        
        tempField = theUCASEField;          /* resuse this memory, its the right size */
        next = **tempField = 0;
        for (i=0;i<numLines;i++) {
                sLen = 1+strlen(*theField+*(lineStarts+order[i]));
                for (j=0;j<sLen;j++,next++) {
                        c = *(*theField+*(lineStarts+order[i])+j);
                        if (c==0) c = '\15';      /* change 0s back to CRs */
                        *(*(tempField)+next) = c;
                }
        }
        next--;
        *(*(tempField)+next) = 0;         /* put a 0 terminator on the result */

        /* clean up */
        
        DisposHandle(orderHandle);
        DisposHandle(lsHandle);
        
        /* return the result */
        
        return tempField;
}


/* XFCN entry point */

pascal void main(paramPtr)
XCmdBlockPtr    paramPtr;
{
        Str255 paramStr,lineStr,itemStr;
        int numItems,i,j;
        char c;
        
        /* Prepare to use globals */
        
        RememberA0();
        SetUpA4();
        
        /* check parameter count */
        
        if (paramPtr->paramCount != 2) {
        strcpy(paramStr,"Not enough parameters in MultiSort.");
        ResultIs(paramPtr,paramStr);
        RestoreA4();
        return;
        }
        
        /* get the input container copy */
        
        MoveHHi(paramPtr->params[0]);
        HLock(paramPtr->params[0]);
        theField = (Handle)paramPtr->params[0];
       
       /* get the specification container */
       
        HLock(paramPtr->params[1]);
        strcpy(paramStr,*(paramPtr->params[1]));
        
        /* check bounds on sort items */
        numSortFields = NumHCLines(paramStr);
        if (numSortFields > maxItems) {
        strcpy(paramStr,"MultiSort cannot handle more than 32 sort items.");
        ResultIs(paramPtr,paramStr);
        RestoreA4();
        return;
        }
        
        /* check each specification line and remember the specs */
        
        for (i=0;i<numSortFields;i++) {
        GetHCLine(i+1,paramStr,lineStr);
        numItems = NumHCItems(lineStr);
        if (numItems != 3) {
        strcpy(paramStr,"Not enough parameters in sort specification line: ");
        NumToString((long)i+1,lineStr);
        PtoCstr((char*)lineStr);
        strcat(paramStr,lineStr);
        ResultIs(paramPtr,paramStr);
        RestoreA4();
        return;
        }
        for (j=0;j<3;j++) {
        GetHCItem(lineStr,j+1,itemStr);
        switch (j) {
        case 0:
        if (ValidStrToNum(itemStr,&sortItem[i])!=TRUE) {
        strcpy(paramStr,"Sort item must be a number in line: ");
        NumToString((long)j+1,lineStr);
        PtoCstr((char*)lineStr);
        strcat(paramStr,lineStr);
        ResultIs(paramPtr,paramStr);
        RestoreA4();
        return;
        }
        break;
        case 1:
        ucase(itemStr);
        if (strcmp(itemStr,"NUMERIC")==0) sortType[i] = numeric;
        else if (strcmp(itemStr,"DATE")==0) sortType[i] = date;
        else if (strcmp(itemStr,"TIME")==0) sortType[i] = time;
        else sortType[i] = alpha;    /* default */
        break;
        case 2:
        ucase(itemStr);
        c = itemStr[0];
        switch (c) {
        case 'A': sortDirection[i] = ascend;break;
        case 'D': sortDirection[i] = descend;break;
        default:  sortDirection[i] = ascend;break;
       }
       break;
        }
        }
        }
        
        /* do the sort */
        paramPtr->returnValue = DoSort(numSortFields);
         
        /* clean up */
        HUnlock (paramPtr->params[0]);
        HUnlock (paramPtr->params[1]);
        RestoreA4(); 
 return;
}



-- part contents for card part 9
----- text -----
MultiSort version 1.0d4
Roger Brown

This is a HyperCard XFCN that sorts the lines of a HyperCard container according to the value of specified items in the line. It will do a multilevel sort on several items and can sort ascending or descending
by alphabetic, numeric, time, or date order.
    There is no limit to the number of lines except for available memory. It uses the Lightspeed C quicksort function and it is quite fast! Only one pass is made over the data to find line starts.
    Case is ignored in this version.
         
     Syntax is:
   
              get MultiSort(container,specification)
   
             where    container is any hypercard container 
                          (field, variable),  presumed to be 
                          multi-lined.
                          specification is a container with this 
                          format:
                          for each item to sort on, in priority 
                          order, specify one line of three 
                          items: item number to sort on,
                          sort type (alpha,numeric,date,time),   
                          and ascending or descending (a,d)

             returns: a copy of the container sorted by 
                           line or error messages.
            
             ex.      get MultiSort(card field 1,spec)
             
                where spec is:
                2,alpha,a         (item 2, alphabetic order,          
                                         ascending)
                3,numeric,d     (then item 3, numeric, 
                                         descending)
                
      Note on data formats:
          Time items must be in format hh:mm:ss (ex. 
          10:15:02). Seconds and hours are optional.  
          MultiSort WILL NOT report improperly 
          formatted times and WILL NOT correct for mis-
          specified time (ex. 9:99 the way that
          HyperCard can. If you are uncertain of time 
          data, convert it to seconds in HyperTalk and 
          sort it numerically.
       
         Date items must be in format mm/dd/yy 
         (ex. 2/15/78). All three parts must be 
         specified.  MultiSort WILL NOT report 
         improperly formatted dates and WILL NOT 
         correct for mis-specified dates (ex. 1/44/50) 
         the way that HyperCard can. If you are 
         uncertain of date data, convert it to seconds
          in HyperTalk and sort it numerically.

REVISION HISTORY
1.0d3 First public release. 
1.0d4 uses international string comparison for alpha 
          sorting.

-- part contents for card part 13
----- text -----
Ford, red, 1975, 4000
Chevy,red,1975,3500
Ford,white,1980,6000
Ford,red,1980,6500
Chevy,white,1985,8000
Buick,blue,1974,2000
Buick,blue,1974,2400
Ford,red,1980,6000

-- part contents for card part 14
----- text -----
1,alpha,a
3,date,a
4,numeric,d

-- part contents for card part 15
----- text -----
Buick,blue,1974,2400
Buick,blue,1974,2000
Chevy,red,1975,3500
Chevy,white,1985,8000
Ford, red, 1975, 4000
Ford,red,1980,6500
Ford,red,1980,6000
Ford,white,1980,6000